home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Online / SpeakFreely / src / libdes / des_locl.h < prev    next >
C/C++ Source or Header  |  2000-05-18  |  9KB  |  274 lines
  1. /* lib/des/des_locl.h */
  2. /* Copyright (C) 1995 Eric Young (eay@mincom.oz.au)
  3.  * All rights reserved.
  4.  * 
  5.  * This file is part of an SSL implementation written
  6.  * by Eric Young (eay@mincom.oz.au).
  7.  * The implementation was written so as to conform with Netscapes SSL
  8.  * specification.  This library and applications are
  9.  * FREE FOR COMMERCIAL AND NON-COMMERCIAL USE
  10.  * as long as the following conditions are aheared to.
  11.  * 
  12.  * Copyright remains Eric Young's, and as such any Copyright notices in
  13.  * the code are not to be removed.  If this code is used in a product,
  14.  * Eric Young should be given attribution as the author of the parts used.
  15.  * This can be in the form of a textual message at program startup or
  16.  * in documentation (online or textual) provided with the package.
  17.  * 
  18.  * Redistribution and use in source and binary forms, with or without
  19.  * modification, are permitted provided that the following conditions
  20.  * are met:
  21.  * 1. Redistributions of source code must retain the copyright
  22.  *    notice, this list of conditions and the following disclaimer.
  23.  * 2. Redistributions in binary form must reproduce the above copyright
  24.  *    notice, this list of conditions and the following disclaimer in the
  25.  *    documentation and/or other materials provided with the distribution.
  26.  * 3. All advertising materials mentioning features or use of this software
  27.  *    must display the following acknowledgement:
  28.  *    This product includes software developed by Eric Young (eay@mincom.oz.au)
  29.  * 
  30.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  31.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  34.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  36.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  37.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  38.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  39.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  40.  * SUCH DAMAGE.
  41.  * 
  42.  * The licence and distribution terms for any publically available version or
  43.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  44.  * copied and put under another distribution licence
  45.  * [including the GNU Public Licence.]
  46.  */
  47.  
  48. #ifndef HEADER_DES_LOCL_H
  49. #define HEADER_DES_LOCL_H
  50. #include <stdio.h>
  51. #include <stdlib.h>
  52. #ifndef MSDOS
  53. #include <unistd.h>
  54. #endif
  55. #include "des.h"
  56.  
  57. /* the following is tweaked from a config script, that is why it is a
  58.  * protected undef/define */
  59. #ifndef DES_USE_PTR
  60. #undef DES_USE_PTR
  61. #endif
  62.  
  63. #ifdef MSDOS        /* Visual C++ 2.1 (Windows NT/95) */
  64. #include <stdlib.h>
  65. #include <time.h>
  66. #include <io.h>
  67. #define RAND
  68. #undef PROTO
  69. #define PROTO
  70. #endif
  71.  
  72. #if defined(__STDC__) || defined(VMS) || defined(M_XENIX) || defined(MSDOS)
  73. #include <string.h>
  74. #endif
  75.  
  76. #ifndef RAND
  77. #define RAND
  78. #endif
  79.  
  80. #ifdef MSDOS
  81. #define getpid() 2
  82. extern int errno;
  83. #define RAND
  84. #undef PROTO
  85. #define PROTO
  86. #endif
  87.  
  88. #if defined(NOCONST)
  89. #define const
  90. #endif
  91.  
  92. #ifdef __STDC__
  93. #undef PROTO
  94. #define PROTO
  95. #endif
  96.  
  97. #ifdef RAND
  98. #define srandom(s) srand(s)
  99. #define random rand
  100. #endif
  101.  
  102. #define ITERATIONS 16
  103. #define HALF_ITERATIONS 8
  104.  
  105. /* used in des_read and des_write */
  106. #define MAXWRITE    (1024*16)
  107. #define BSIZE        (MAXWRITE+4)
  108.  
  109. #define c2l(c,l)    (l =((unsigned long)(*((c)++)))    , \
  110.              l|=((unsigned long)(*((c)++)))<< 8L, \
  111.              l|=((unsigned long)(*((c)++)))<<16L, \
  112.              l|=((unsigned long)(*((c)++)))<<24L)
  113.  
  114. /* NOTE - c is not incremented as per c2l */
  115. #define c2ln(c,l1,l2,n)    { \
  116.             c+=n; \
  117.             l1=l2=0; \
  118.             switch (n) { \
  119.             case 8: l2 =((unsigned long)(*(--(c))))<<24L; \
  120.             case 7: l2|=((unsigned long)(*(--(c))))<<16L; \
  121.             case 6: l2|=((unsigned long)(*(--(c))))<< 8L; \
  122.             case 5: l2|=((unsigned long)(*(--(c))));     \
  123.             case 4: l1 =((unsigned long)(*(--(c))))<<24L; \
  124.             case 3: l1|=((unsigned long)(*(--(c))))<<16L; \
  125.             case 2: l1|=((unsigned long)(*(--(c))))<< 8L; \
  126.             case 1: l1|=((unsigned long)(*(--(c))));     \
  127.                 } \
  128.             }
  129.  
  130. #define l2c(l,c)    (*((c)++)=(unsigned char)(((l)     )&0xff), \
  131.              *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
  132.              *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
  133.              *((c)++)=(unsigned char)(((l)>>24L)&0xff))
  134.  
  135. /* replacements for htonl and ntohl since I have no idea what to do
  136.  * when faced with machines with 8 byte longs. */
  137. #define HDRSIZE 4
  138.  
  139. #define n2l(c,l)    (l =((unsigned long)(*((c)++)))<<24L, \
  140.              l|=((unsigned long)(*((c)++)))<<16L, \
  141.              l|=((unsigned long)(*((c)++)))<< 8L, \
  142.              l|=((unsigned long)(*((c)++))))
  143.  
  144. #define l2n(l,c)    (*((c)++)=(unsigned char)(((l)>>24L)&0xff), \
  145.              *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
  146.              *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
  147.              *((c)++)=(unsigned char)(((l)     )&0xff))
  148.  
  149. /* NOTE - c is not incremented as per l2c */
  150. #define l2cn(l1,l2,c,n)    { \
  151.             c+=n; \
  152.             switch (n) { \
  153.             case 8: *(--(c))=(unsigned char)(((l2)>>24L)&0xff); \
  154.             case 7: *(--(c))=(unsigned char)(((l2)>>16L)&0xff); \
  155.             case 6: *(--(c))=(unsigned char)(((l2)>> 8L)&0xff); \
  156.             case 5: *(--(c))=(unsigned char)(((l2)     )&0xff); \
  157.             case 4: *(--(c))=(unsigned char)(((l1)>>24L)&0xff); \
  158.             case 3: *(--(c))=(unsigned char)(((l1)>>16L)&0xff); \
  159.             case 2: *(--(c))=(unsigned char)(((l1)>> 8L)&0xff); \
  160.             case 1: *(--(c))=(unsigned char)(((l1)     )&0xff); \
  161.                 } \
  162.             }
  163.  
  164. /* The changes to this macro may help or hinder, depending on the
  165.  * compiler and the achitecture.  gcc2 always seems to do well :-).
  166.  * Inspired by Dana How <how@isl.stanford.edu>
  167.  * DO NOT use the alternative version on machines with 8 byte longs. */
  168. #ifdef DES_USR_PTR
  169. #define D_ENCRYPT(L,R,S) { \
  170.     u=((R^s[S  ])<<2);    \
  171.     t= R^s[S+1]; \
  172.     t=((t>>2)+(t<<30)); \
  173.     L^= \
  174.     *(unsigned long *)(des_SP+0x0100+((t    )&0xfc))+ \
  175.     *(unsigned long *)(des_SP+0x0300+((t>> 8)&0xfc))+ \
  176.     *(unsigned long *)(des_SP+0x0500+((t>>16)&0xfc))+ \
  177.     *(unsigned long *)(des_SP+0x0700+((t>>24)&0xfc))+ \
  178.     *(unsigned long *)(des_SP+       ((u    )&0xfc))+ \
  179.     *(unsigned long *)(des_SP+0x0200+((u>> 8)&0xfc))+ \
  180.     *(unsigned long *)(des_SP+0x0400+((u>>16)&0xfc))+ \
  181.     *(unsigned long *)(des_SP+0x0600+((u>>24)&0xfc)); }
  182. #else /* original version */
  183. #ifdef MSDOS
  184. #define D_ENCRYPT(L,R,S)    \
  185.     U.l=R^s[S+1]; \
  186.     T.s[0]=((U.s[0]>>4)|(U.s[1]<<12))&0x3f3f; \
  187.     T.s[1]=((U.s[1]>>4)|(U.s[0]<<12))&0x3f3f; \
  188.     U.l=(R^s[S  ])&0x3f3f3f3fL; \
  189.     L^=    des_SPtrans[1][(T.c[0])]| \
  190.         des_SPtrans[3][(T.c[1])]| \
  191.         des_SPtrans[5][(T.c[2])]| \
  192.         des_SPtrans[7][(T.c[3])]| \
  193.         des_SPtrans[0][(U.c[0])]| \
  194.         des_SPtrans[2][(U.c[1])]| \
  195.         des_SPtrans[4][(U.c[2])]| \
  196.         des_SPtrans[6][(U.c[3])];
  197. #else
  198. #define D_ENCRYPT(Q,R,S) {\
  199.     u=(R^s[S  ]); \
  200.     t=R^s[S+1]; \
  201.     t=((t>>4L)+(t<<28L)); \
  202.     Q^=    des_SPtrans[1][(t     )&0x3f]| \
  203.         des_SPtrans[3][(t>> 8L)&0x3f]| \
  204.         des_SPtrans[5][(t>>16L)&0x3f]| \
  205.         des_SPtrans[7][(t>>24L)&0x3f]| \
  206.         des_SPtrans[0][(u     )&0x3f]| \
  207.         des_SPtrans[2][(u>> 8L)&0x3f]| \
  208.         des_SPtrans[4][(u>>16L)&0x3f]| \
  209.         des_SPtrans[6][(u>>24L)&0x3f]; }
  210. #endif
  211. #endif
  212.  
  213.     /* IP and FP
  214.      * The problem is more of a geometric problem that random bit fiddling.
  215.      0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
  216.      8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
  217.     16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
  218.     24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
  219.  
  220.     32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
  221.     40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
  222.     48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
  223.     56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
  224.  
  225.     The output has been subject to swaps of the form
  226.     0 1 -> 3 1 but the odd and even bits have been put into
  227.     2 3    2 0
  228.     different words.  The main trick is to remember that
  229.     t=((l>>size)^r)&(mask);
  230.     r^=t;
  231.     l^=(t<<size);
  232.     can be used to swap and move bits between words.
  233.  
  234.     So l =  0  1  2  3  r = 16 17 18 19
  235.             4  5  6  7      20 21 22 23
  236.             8  9 10 11      24 25 26 27
  237.            12 13 14 15      28 29 30 31
  238.     becomes (for size == 2 and mask == 0x3333)
  239.        t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
  240.          6^20  7^21 -- --        4  5 20 21       6  7 22 23
  241.         10^24 11^25 -- --        8  9 24 25      10 11 24 25
  242.         14^28 15^29 -- --       12 13 28 29      14 15 28 29
  243.  
  244.     Thanks for hints from Richard Outerbridge - he told me IP&FP
  245.     could be done in 15 xor, 10 shifts and 5 ands.
  246.     When I finally started to think of the problem in 2D
  247.     I first got ~42 operations without xors.  When I remembered
  248.     how to use xors :-) I got it to its final state.
  249.     */
  250. #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
  251.     (b)^=(t),\
  252.     (a)^=((t)<<(n)))
  253.  
  254. #define IP(l,r) \
  255.     { \
  256.     register unsigned long tt; \
  257.     PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \
  258.     PERM_OP(l,r,tt,16,0x0000ffffL); \
  259.     PERM_OP(r,l,tt, 2,0x33333333L); \
  260.     PERM_OP(l,r,tt, 8,0x00ff00ffL); \
  261.     PERM_OP(r,l,tt, 1,0x55555555L); \
  262.     }
  263.  
  264. #define FP(l,r) \
  265.     { \
  266.     register unsigned long tt; \
  267.     PERM_OP(l,r,tt, 1,0x55555555L); \
  268.     PERM_OP(r,l,tt, 8,0x00ff00ffL); \
  269.     PERM_OP(l,r,tt, 2,0x33333333L); \
  270.     PERM_OP(r,l,tt,16,0x0000ffffL); \
  271.     PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \
  272.     }
  273. #endif
  274.